//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS DataExchange service.
///
/// AWS Data Exchange is a service that makes it easy for AWS customers to exchange data in the cloud. You can use the AWS Data Exchange APIs to create, update, manage, and access file-based data set in the AWS Cloud. As a subscriber, you can view and access the data sets that you have an entitlement to through a subscription. You can use the APIs to download or copy your entitled data sets to Amazon Simple Storage Service (Amazon S3) for use across a variety of AWS analytics and machine learning services. As a provider, you can create and manage your data sets that you would like to publish to a product. Being able to package and provide your data sets into products requires a few steps to determine eligibility. For more information, visit the AWS Data Exchange User Guide. A data set is a collection of data that can be changed or updated over time. Data sets can be updated using revisions, which represent a new version or incremental change to a data set. A revision contains one or more assets. An asset in AWS Data Exchange is a piece of data that can be stored as an Amazon S3 object, Redshift datashare, API Gateway API, AWS Lake Formation data permission, or Amazon S3 data access. The asset can be a structured data file, an image file, or some other data file. Jobs are asynchronous import or export operations used to create or copy assets.
public struct DataExchange: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the DataExchange client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "DataExchange",
            serviceIdentifier: "dataexchange",
            serviceProtocol: .restjson,
            apiVersion: "2017-07-25",
            endpoint: endpoint,
            errorType: DataExchangeErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }





    // MARK: API Calls

    /// This operation accepts a data grant.
    @Sendable
    @inlinable
    public func acceptDataGrant(_ input: AcceptDataGrantRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AcceptDataGrantResponse {
        try await self.client.execute(
            operation: "AcceptDataGrant", 
            path: "/v1/data-grants/{DataGrantArn}/accept", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation accepts a data grant.
    ///
    /// Parameters:
    ///   - dataGrantArn: The Amazon Resource Name (ARN) of the data grant to accept.
    ///   - logger: Logger use during operation
    @inlinable
    public func acceptDataGrant(
        dataGrantArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AcceptDataGrantResponse {
        let input = AcceptDataGrantRequest(
            dataGrantArn: dataGrantArn
        )
        return try await self.acceptDataGrant(input, logger: logger)
    }

    /// This operation cancels a job. Jobs can be cancelled only when they are in the WAITING state.
    @Sendable
    @inlinable
    public func cancelJob(_ input: CancelJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "CancelJob", 
            path: "/v1/jobs/{JobId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation cancels a job. Jobs can be cancelled only when they are in the WAITING state.
    ///
    /// Parameters:
    ///   - jobId: The unique identifier for a job.
    ///   - logger: Logger use during operation
    @inlinable
    public func cancelJob(
        jobId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = CancelJobRequest(
            jobId: jobId
        )
        return try await self.cancelJob(input, logger: logger)
    }

    /// This operation creates a data grant.
    @Sendable
    @inlinable
    public func createDataGrant(_ input: CreateDataGrantRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateDataGrantResponse {
        try await self.client.execute(
            operation: "CreateDataGrant", 
            path: "/v1/data-grants", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation creates a data grant.
    ///
    /// Parameters:
    ///   - description: The description of the data grant.
    ///   - endsAt: The timestamp of when access to the associated data set ends.
    ///   - grantDistributionScope: The distribution scope of the data grant.
    ///   - name: The name of the data grant.
    ///   - receiverPrincipal: The Amazon Web Services account ID of the data grant receiver.
    ///   - sourceDataSetId: The ID of the data set used to create the data grant.
    ///   - tags: The tags to add to the data grant. A tag is a key-value pair.
    ///   - logger: Logger use during operation
    @inlinable
    public func createDataGrant(
        description: String? = nil,
        endsAt: Date? = nil,
        grantDistributionScope: GrantDistributionScope,
        name: String,
        receiverPrincipal: String,
        sourceDataSetId: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateDataGrantResponse {
        let input = CreateDataGrantRequest(
            description: description, 
            endsAt: endsAt, 
            grantDistributionScope: grantDistributionScope, 
            name: name, 
            receiverPrincipal: receiverPrincipal, 
            sourceDataSetId: sourceDataSetId, 
            tags: tags
        )
        return try await self.createDataGrant(input, logger: logger)
    }

    /// This operation creates a data set.
    @Sendable
    @inlinable
    public func createDataSet(_ input: CreateDataSetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateDataSetResponse {
        try await self.client.execute(
            operation: "CreateDataSet", 
            path: "/v1/data-sets", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation creates a data set.
    ///
    /// Parameters:
    ///   - assetType: The type of asset that is added to a data set.
    ///   - description: A description for the data set. This value can be up to 16,348 characters long.
    ///   - name: The name of the data set.
    ///   - tags: A data set tag is an optional label that you can assign to a data set when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to these data sets and revisions.
    ///   - logger: Logger use during operation
    @inlinable
    public func createDataSet(
        assetType: AssetType,
        description: String,
        name: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateDataSetResponse {
        let input = CreateDataSetRequest(
            assetType: assetType, 
            description: description, 
            name: name, 
            tags: tags
        )
        return try await self.createDataSet(input, logger: logger)
    }

    /// This operation creates an event action.
    @Sendable
    @inlinable
    public func createEventAction(_ input: CreateEventActionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateEventActionResponse {
        try await self.client.execute(
            operation: "CreateEventAction", 
            path: "/v1/event-actions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation creates an event action.
    ///
    /// Parameters:
    ///   - action: What occurs after a certain event.
    ///   - event: What occurs to start an action.
    ///   - tags: Key-value pairs that you can associate with the event action.
    ///   - logger: Logger use during operation
    @inlinable
    public func createEventAction(
        action: Action,
        event: Event,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateEventActionResponse {
        let input = CreateEventActionRequest(
            action: action, 
            event: event, 
            tags: tags
        )
        return try await self.createEventAction(input, logger: logger)
    }

    /// This operation creates a job.
    @Sendable
    @inlinable
    public func createJob(_ input: CreateJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateJobResponse {
        try await self.client.execute(
            operation: "CreateJob", 
            path: "/v1/jobs", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation creates a job.
    ///
    /// Parameters:
    ///   - details: The details for the CreateJob request.
    ///   - type: The type of job to be created.
    ///   - logger: Logger use during operation
    @inlinable
    public func createJob(
        details: RequestDetails,
        type: `Type`,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateJobResponse {
        let input = CreateJobRequest(
            details: details, 
            type: type
        )
        return try await self.createJob(input, logger: logger)
    }

    /// This operation creates a revision for a data set.
    @Sendable
    @inlinable
    public func createRevision(_ input: CreateRevisionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateRevisionResponse {
        try await self.client.execute(
            operation: "CreateRevision", 
            path: "/v1/data-sets/{DataSetId}/revisions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation creates a revision for a data set.
    ///
    /// Parameters:
    ///   - comment: An optional comment about the revision.
    ///   - dataSetId: The unique identifier for a data set.
    ///   - tags: A revision tag is an optional label that you can assign to a revision when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to these data sets and revisions.
    ///   - logger: Logger use during operation
    @inlinable
    public func createRevision(
        comment: String? = nil,
        dataSetId: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateRevisionResponse {
        let input = CreateRevisionRequest(
            comment: comment, 
            dataSetId: dataSetId, 
            tags: tags
        )
        return try await self.createRevision(input, logger: logger)
    }

    /// This operation deletes an asset.
    @Sendable
    @inlinable
    public func deleteAsset(_ input: DeleteAssetRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteAsset", 
            path: "/v1/data-sets/{DataSetId}/revisions/{RevisionId}/assets/{AssetId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation deletes an asset.
    ///
    /// Parameters:
    ///   - assetId: The unique identifier for an asset.
    ///   - dataSetId: The unique identifier for a data set.
    ///   - revisionId: The unique identifier for a revision.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAsset(
        assetId: String,
        dataSetId: String,
        revisionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteAssetRequest(
            assetId: assetId, 
            dataSetId: dataSetId, 
            revisionId: revisionId
        )
        return try await self.deleteAsset(input, logger: logger)
    }

    /// This operation deletes a data grant.
    @Sendable
    @inlinable
    public func deleteDataGrant(_ input: DeleteDataGrantRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteDataGrant", 
            path: "/v1/data-grants/{DataGrantId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation deletes a data grant.
    ///
    /// Parameters:
    ///   - dataGrantId: The ID of the data grant to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteDataGrant(
        dataGrantId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteDataGrantRequest(
            dataGrantId: dataGrantId
        )
        return try await self.deleteDataGrant(input, logger: logger)
    }

    /// This operation deletes a data set.
    @Sendable
    @inlinable
    public func deleteDataSet(_ input: DeleteDataSetRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteDataSet", 
            path: "/v1/data-sets/{DataSetId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation deletes a data set.
    ///
    /// Parameters:
    ///   - dataSetId: The unique identifier for a data set.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteDataSet(
        dataSetId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteDataSetRequest(
            dataSetId: dataSetId
        )
        return try await self.deleteDataSet(input, logger: logger)
    }

    /// This operation deletes the event action.
    @Sendable
    @inlinable
    public func deleteEventAction(_ input: DeleteEventActionRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteEventAction", 
            path: "/v1/event-actions/{EventActionId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation deletes the event action.
    ///
    /// Parameters:
    ///   - eventActionId: The unique identifier for the event action.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteEventAction(
        eventActionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteEventActionRequest(
            eventActionId: eventActionId
        )
        return try await self.deleteEventAction(input, logger: logger)
    }

    /// This operation deletes a revision.
    @Sendable
    @inlinable
    public func deleteRevision(_ input: DeleteRevisionRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteRevision", 
            path: "/v1/data-sets/{DataSetId}/revisions/{RevisionId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation deletes a revision.
    ///
    /// Parameters:
    ///   - dataSetId: The unique identifier for a data set.
    ///   - revisionId: The unique identifier for a revision.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteRevision(
        dataSetId: String,
        revisionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteRevisionRequest(
            dataSetId: dataSetId, 
            revisionId: revisionId
        )
        return try await self.deleteRevision(input, logger: logger)
    }

    /// This operation returns information about an asset.
    @Sendable
    @inlinable
    public func getAsset(_ input: GetAssetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAssetResponse {
        try await self.client.execute(
            operation: "GetAsset", 
            path: "/v1/data-sets/{DataSetId}/revisions/{RevisionId}/assets/{AssetId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation returns information about an asset.
    ///
    /// Parameters:
    ///   - assetId: The unique identifier for an asset.
    ///   - dataSetId: The unique identifier for a data set.
    ///   - revisionId: The unique identifier for a revision.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAsset(
        assetId: String,
        dataSetId: String,
        revisionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAssetResponse {
        let input = GetAssetRequest(
            assetId: assetId, 
            dataSetId: dataSetId, 
            revisionId: revisionId
        )
        return try await self.getAsset(input, logger: logger)
    }

    /// This operation returns information about a data grant.
    @Sendable
    @inlinable
    public func getDataGrant(_ input: GetDataGrantRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDataGrantResponse {
        try await self.client.execute(
            operation: "GetDataGrant", 
            path: "/v1/data-grants/{DataGrantId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation returns information about a data grant.
    ///
    /// Parameters:
    ///   - dataGrantId: The ID of the data grant.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDataGrant(
        dataGrantId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDataGrantResponse {
        let input = GetDataGrantRequest(
            dataGrantId: dataGrantId
        )
        return try await self.getDataGrant(input, logger: logger)
    }

    /// This operation returns information about a data set.
    @Sendable
    @inlinable
    public func getDataSet(_ input: GetDataSetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDataSetResponse {
        try await self.client.execute(
            operation: "GetDataSet", 
            path: "/v1/data-sets/{DataSetId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation returns information about a data set.
    ///
    /// Parameters:
    ///   - dataSetId: The unique identifier for a data set.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDataSet(
        dataSetId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDataSetResponse {
        let input = GetDataSetRequest(
            dataSetId: dataSetId
        )
        return try await self.getDataSet(input, logger: logger)
    }

    /// This operation retrieves information about an event action.
    @Sendable
    @inlinable
    public func getEventAction(_ input: GetEventActionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetEventActionResponse {
        try await self.client.execute(
            operation: "GetEventAction", 
            path: "/v1/event-actions/{EventActionId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation retrieves information about an event action.
    ///
    /// Parameters:
    ///   - eventActionId: The unique identifier for the event action.
    ///   - logger: Logger use during operation
    @inlinable
    public func getEventAction(
        eventActionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetEventActionResponse {
        let input = GetEventActionRequest(
            eventActionId: eventActionId
        )
        return try await self.getEventAction(input, logger: logger)
    }

    /// This operation returns information about a job.
    @Sendable
    @inlinable
    public func getJob(_ input: GetJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetJobResponse {
        try await self.client.execute(
            operation: "GetJob", 
            path: "/v1/jobs/{JobId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation returns information about a job.
    ///
    /// Parameters:
    ///   - jobId: The unique identifier for a job.
    ///   - logger: Logger use during operation
    @inlinable
    public func getJob(
        jobId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetJobResponse {
        let input = GetJobRequest(
            jobId: jobId
        )
        return try await self.getJob(input, logger: logger)
    }

    /// This operation returns information about a received data grant.
    @Sendable
    @inlinable
    public func getReceivedDataGrant(_ input: GetReceivedDataGrantRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetReceivedDataGrantResponse {
        try await self.client.execute(
            operation: "GetReceivedDataGrant", 
            path: "/v1/received-data-grants/{DataGrantArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation returns information about a received data grant.
    ///
    /// Parameters:
    ///   - dataGrantArn: The Amazon Resource Name (ARN) of the data grant.
    ///   - logger: Logger use during operation
    @inlinable
    public func getReceivedDataGrant(
        dataGrantArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetReceivedDataGrantResponse {
        let input = GetReceivedDataGrantRequest(
            dataGrantArn: dataGrantArn
        )
        return try await self.getReceivedDataGrant(input, logger: logger)
    }

    /// This operation returns information about a revision.
    @Sendable
    @inlinable
    public func getRevision(_ input: GetRevisionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetRevisionResponse {
        try await self.client.execute(
            operation: "GetRevision", 
            path: "/v1/data-sets/{DataSetId}/revisions/{RevisionId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation returns information about a revision.
    ///
    /// Parameters:
    ///   - dataSetId: The unique identifier for a data set.
    ///   - revisionId: The unique identifier for a revision.
    ///   - logger: Logger use during operation
    @inlinable
    public func getRevision(
        dataSetId: String,
        revisionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetRevisionResponse {
        let input = GetRevisionRequest(
            dataSetId: dataSetId, 
            revisionId: revisionId
        )
        return try await self.getRevision(input, logger: logger)
    }

    /// This operation returns information about all data grants.
    @Sendable
    @inlinable
    public func listDataGrants(_ input: ListDataGrantsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDataGrantsResponse {
        try await self.client.execute(
            operation: "ListDataGrants", 
            path: "/v1/data-grants", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation returns information about all data grants.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - nextToken: The pagination token used to retrieve the next page of results for this operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDataGrants(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDataGrantsResponse {
        let input = ListDataGrantsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listDataGrants(input, logger: logger)
    }

    /// This operation lists a data set's revisions sorted by CreatedAt in descending order.
    @Sendable
    @inlinable
    public func listDataSetRevisions(_ input: ListDataSetRevisionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDataSetRevisionsResponse {
        try await self.client.execute(
            operation: "ListDataSetRevisions", 
            path: "/v1/data-sets/{DataSetId}/revisions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation lists a data set's revisions sorted by CreatedAt in descending order.
    ///
    /// Parameters:
    ///   - dataSetId: The unique identifier for a data set.
    ///   - maxResults: The maximum number of results returned by a single call.
    ///   - nextToken: The token value retrieved from a previous call to access the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDataSetRevisions(
        dataSetId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDataSetRevisionsResponse {
        let input = ListDataSetRevisionsRequest(
            dataSetId: dataSetId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listDataSetRevisions(input, logger: logger)
    }

    /// This operation lists your data sets. When listing by origin OWNED, results are sorted by CreatedAt in descending order. When listing by origin ENTITLED, there is no order.
    @Sendable
    @inlinable
    public func listDataSets(_ input: ListDataSetsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDataSetsResponse {
        try await self.client.execute(
            operation: "ListDataSets", 
            path: "/v1/data-sets", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation lists your data sets. When listing by origin OWNED, results are sorted by CreatedAt in descending order. When listing by origin ENTITLED, there is no order.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results returned by a single call.
    ///   - nextToken: The token value retrieved from a previous call to access the next page of results.
    ///   - origin: A property that defines the data set as OWNED by the account (for providers) or ENTITLED to the account (for subscribers).
    ///   - logger: Logger use during operation
    @inlinable
    public func listDataSets(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        origin: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDataSetsResponse {
        let input = ListDataSetsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            origin: origin
        )
        return try await self.listDataSets(input, logger: logger)
    }

    /// This operation lists your event actions.
    @Sendable
    @inlinable
    public func listEventActions(_ input: ListEventActionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListEventActionsResponse {
        try await self.client.execute(
            operation: "ListEventActions", 
            path: "/v1/event-actions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation lists your event actions.
    ///
    /// Parameters:
    ///   - eventSourceId: The unique identifier for the event source.
    ///   - maxResults: The maximum number of results returned by a single call.
    ///   - nextToken: The token value retrieved from a previous call to access the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listEventActions(
        eventSourceId: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListEventActionsResponse {
        let input = ListEventActionsRequest(
            eventSourceId: eventSourceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listEventActions(input, logger: logger)
    }

    /// This operation lists your jobs sorted by CreatedAt in descending order.
    @Sendable
    @inlinable
    public func listJobs(_ input: ListJobsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListJobsResponse {
        try await self.client.execute(
            operation: "ListJobs", 
            path: "/v1/jobs", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation lists your jobs sorted by CreatedAt in descending order.
    ///
    /// Parameters:
    ///   - dataSetId: The unique identifier for a data set.
    ///   - maxResults: The maximum number of results returned by a single call.
    ///   - nextToken: The token value retrieved from a previous call to access the next page of results.
    ///   - revisionId: The unique identifier for a revision.
    ///   - logger: Logger use during operation
    @inlinable
    public func listJobs(
        dataSetId: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        revisionId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListJobsResponse {
        let input = ListJobsRequest(
            dataSetId: dataSetId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            revisionId: revisionId
        )
        return try await self.listJobs(input, logger: logger)
    }

    /// This operation returns information about all received data grants.
    @Sendable
    @inlinable
    public func listReceivedDataGrants(_ input: ListReceivedDataGrantsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListReceivedDataGrantsResponse {
        try await self.client.execute(
            operation: "ListReceivedDataGrants", 
            path: "/v1/received-data-grants", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation returns information about all received data grants.
    ///
    /// Parameters:
    ///   - acceptanceState: The acceptance state of the data grants to list.
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - nextToken: The pagination token used to retrieve the next page of results for this operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func listReceivedDataGrants(
        acceptanceState: [AcceptanceStateFilterValue]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListReceivedDataGrantsResponse {
        let input = ListReceivedDataGrantsRequest(
            acceptanceState: acceptanceState, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listReceivedDataGrants(input, logger: logger)
    }

    /// This operation lists a revision's assets sorted alphabetically in descending order.
    @Sendable
    @inlinable
    public func listRevisionAssets(_ input: ListRevisionAssetsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListRevisionAssetsResponse {
        try await self.client.execute(
            operation: "ListRevisionAssets", 
            path: "/v1/data-sets/{DataSetId}/revisions/{RevisionId}/assets", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation lists a revision's assets sorted alphabetically in descending order.
    ///
    /// Parameters:
    ///   - dataSetId: The unique identifier for a data set.
    ///   - maxResults: The maximum number of results returned by a single call.
    ///   - nextToken: The token value retrieved from a previous call to access the next page of results.
    ///   - revisionId: The unique identifier for a revision.
    ///   - logger: Logger use during operation
    @inlinable
    public func listRevisionAssets(
        dataSetId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        revisionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListRevisionAssetsResponse {
        let input = ListRevisionAssetsRequest(
            dataSetId: dataSetId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            revisionId: revisionId
        )
        return try await self.listRevisionAssets(input, logger: logger)
    }

    /// This operation lists the tags on the resource.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags/{ResourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation lists the tags on the resource.
    ///
    /// Parameters:
    ///   - resourceArn: An Amazon Resource Name (ARN) that uniquely identifies an AWS resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// This operation revokes subscribers' access to a revision.
    @Sendable
    @inlinable
    public func revokeRevision(_ input: RevokeRevisionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RevokeRevisionResponse {
        try await self.client.execute(
            operation: "RevokeRevision", 
            path: "/v1/data-sets/{DataSetId}/revisions/{RevisionId}/revoke", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation revokes subscribers' access to a revision.
    ///
    /// Parameters:
    ///   - dataSetId: The unique identifier for a data set.
    ///   - revisionId: The unique identifier for a revision.
    ///   - revocationComment: A required comment to inform subscribers of the reason their access to the revision was revoked.
    ///   - logger: Logger use during operation
    @inlinable
    public func revokeRevision(
        dataSetId: String,
        revisionId: String,
        revocationComment: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RevokeRevisionResponse {
        let input = RevokeRevisionRequest(
            dataSetId: dataSetId, 
            revisionId: revisionId, 
            revocationComment: revocationComment
        )
        return try await self.revokeRevision(input, logger: logger)
    }

    /// This operation invokes an API Gateway API asset. The request is proxied to the provider’s API Gateway API.
    @Sendable
    @inlinable
    public func sendApiAsset(_ input: SendApiAssetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SendApiAssetResponse {
        try await self.client.execute(
            operation: "SendApiAsset", 
            path: "/v1", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "api-fulfill.", 
            logger: logger
        )
    }
    /// This operation invokes an API Gateway API asset. The request is proxied to the provider’s API Gateway API.
    ///
    /// Parameters:
    ///   - assetId: Asset ID value for the API request.
    ///   - body: The request body.
    ///   - dataSetId: Data set ID value for the API request.
    ///   - method: HTTP method value for the API request. Alternatively, you can use the appropriate verb in your request.
    ///   - path: URI path value for the API request. Alternatively, you can set the URI path directly by invoking /v1/{pathValue}.
    ///   - queryStringParameters: Attach query string parameters to the end of the URI (for example, /v1/examplePath?exampleParam=exampleValue).
    ///   - requestHeaders: Any header value prefixed with x-amzn-dataexchange-header- will have that stripped before sending the Asset API request. Use this when you want to override a header that AWS Data Exchange uses. Alternatively, you can use the header without a prefix to the HTTP request.
    ///   - revisionId: Revision ID value for the API request.
    ///   - logger: Logger use during operation
    @inlinable
    public func sendApiAsset(
        assetId: String,
        body: String? = nil,
        dataSetId: String,
        method: String? = nil,
        path: String? = nil,
        queryStringParameters: [String: String]? = nil,
        requestHeaders: [String: String]? = nil,
        revisionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SendApiAssetResponse {
        let input = SendApiAssetRequest(
            assetId: assetId, 
            body: body, 
            dataSetId: dataSetId, 
            method: method, 
            path: path, 
            queryStringParameters: queryStringParameters, 
            requestHeaders: requestHeaders, 
            revisionId: revisionId
        )
        return try await self.sendApiAsset(input, logger: logger)
    }

    /// The type of event associated with the data set.
    @Sendable
    @inlinable
    public func sendDataSetNotification(_ input: SendDataSetNotificationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SendDataSetNotificationResponse {
        try await self.client.execute(
            operation: "SendDataSetNotification", 
            path: "/v1/data-sets/{DataSetId}/notification", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// The type of event associated with the data set.
    ///
    /// Parameters:
    ///   - clientToken: Idempotency key for the notification, this key allows us to deduplicate notifications that are sent in quick succession erroneously.
    ///   - comment: Free-form text field for providers to add information about their notifications.
    ///   - dataSetId: Affected data set of the notification.
    ///   - details: Extra details specific to this notification type.
    ///   - scope: Affected scope of this notification such as the underlying resources affected by the notification event.
    ///   - type: The type of the notification. Describing the kind of event the notification is alerting you to.
    ///   - logger: Logger use during operation
    @inlinable
    public func sendDataSetNotification(
        clientToken: String? = SendDataSetNotificationRequest.idempotencyToken(),
        comment: String? = nil,
        dataSetId: String,
        details: NotificationDetails? = nil,
        scope: ScopeDetails? = nil,
        type: NotificationType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SendDataSetNotificationResponse {
        let input = SendDataSetNotificationRequest(
            clientToken: clientToken, 
            comment: comment, 
            dataSetId: dataSetId, 
            details: details, 
            scope: scope, 
            type: type
        )
        return try await self.sendDataSetNotification(input, logger: logger)
    }

    /// This operation starts a job.
    @Sendable
    @inlinable
    public func startJob(_ input: StartJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartJobResponse {
        try await self.client.execute(
            operation: "StartJob", 
            path: "/v1/jobs/{JobId}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation starts a job.
    ///
    /// Parameters:
    ///   - jobId: The unique identifier for a job.
    ///   - logger: Logger use during operation
    @inlinable
    public func startJob(
        jobId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartJobResponse {
        let input = StartJobRequest(
            jobId: jobId
        )
        return try await self.startJob(input, logger: logger)
    }

    /// This operation tags a resource.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{ResourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation tags a resource.
    ///
    /// Parameters:
    ///   - resourceArn: An Amazon Resource Name (ARN) that uniquely identifies an AWS resource.
    ///   - tags: A label that consists of a customer-defined key and an optional value.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [String: String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// This operation removes one or more tags from a resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{ResourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation removes one or more tags from a resource.
    ///
    /// Parameters:
    ///   - resourceArn: An Amazon Resource Name (ARN) that uniquely identifies an AWS resource.
    ///   - tagKeys: The key tags.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// This operation updates an asset.
    @Sendable
    @inlinable
    public func updateAsset(_ input: UpdateAssetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAssetResponse {
        try await self.client.execute(
            operation: "UpdateAsset", 
            path: "/v1/data-sets/{DataSetId}/revisions/{RevisionId}/assets/{AssetId}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation updates an asset.
    ///
    /// Parameters:
    ///   - assetId: The unique identifier for an asset.
    ///   - dataSetId: The unique identifier for a data set.
    ///   - name: The name of the asset. When importing from Amazon S3, the Amazon S3 object key is used as the asset name. When exporting to Amazon S3, the asset name is used as default target Amazon S3 object key. When importing from Amazon API Gateway API, the API name is used as the asset name. When importing from Amazon Redshift, the datashare name is used as the asset name. When importing from AWS Lake Formation, the static values of "Database(s) included in the LF-tag policy" or "Table(s) included in LF-tag policy" are used as the name.
    ///   - revisionId: The unique identifier for a revision.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAsset(
        assetId: String,
        dataSetId: String,
        name: String,
        revisionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAssetResponse {
        let input = UpdateAssetRequest(
            assetId: assetId, 
            dataSetId: dataSetId, 
            name: name, 
            revisionId: revisionId
        )
        return try await self.updateAsset(input, logger: logger)
    }

    /// This operation updates a data set.
    @Sendable
    @inlinable
    public func updateDataSet(_ input: UpdateDataSetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateDataSetResponse {
        try await self.client.execute(
            operation: "UpdateDataSet", 
            path: "/v1/data-sets/{DataSetId}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation updates a data set.
    ///
    /// Parameters:
    ///   - dataSetId: The unique identifier for a data set.
    ///   - description: The description for the data set.
    ///   - name: The name of the data set.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateDataSet(
        dataSetId: String,
        description: String? = nil,
        name: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateDataSetResponse {
        let input = UpdateDataSetRequest(
            dataSetId: dataSetId, 
            description: description, 
            name: name
        )
        return try await self.updateDataSet(input, logger: logger)
    }

    /// This operation updates the event action.
    @Sendable
    @inlinable
    public func updateEventAction(_ input: UpdateEventActionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateEventActionResponse {
        try await self.client.execute(
            operation: "UpdateEventAction", 
            path: "/v1/event-actions/{EventActionId}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation updates the event action.
    ///
    /// Parameters:
    ///   - action: What occurs after a certain event.
    ///   - eventActionId: The unique identifier for the event action.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateEventAction(
        action: Action? = nil,
        eventActionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateEventActionResponse {
        let input = UpdateEventActionRequest(
            action: action, 
            eventActionId: eventActionId
        )
        return try await self.updateEventAction(input, logger: logger)
    }

    /// This operation updates a revision.
    @Sendable
    @inlinable
    public func updateRevision(_ input: UpdateRevisionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateRevisionResponse {
        try await self.client.execute(
            operation: "UpdateRevision", 
            path: "/v1/data-sets/{DataSetId}/revisions/{RevisionId}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation updates a revision.
    ///
    /// Parameters:
    ///   - comment: An optional comment about the revision.
    ///   - dataSetId: The unique identifier for a data set.
    ///   - finalized: Finalizing a revision tells AWS Data Exchange that your changes to the assets in the revision are complete. After it's in this read-only state, you can publish the revision to your products.
    ///   - revisionId: The unique identifier for a revision.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateRevision(
        comment: String? = nil,
        dataSetId: String,
        finalized: Bool? = nil,
        revisionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateRevisionResponse {
        let input = UpdateRevisionRequest(
            comment: comment, 
            dataSetId: dataSetId, 
            finalized: finalized, 
            revisionId: revisionId
        )
        return try await self.updateRevision(input, logger: logger)
    }
}

extension DataExchange {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: DataExchange, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension DataExchange {
    /// Return PaginatorSequence for operation ``listDataGrants(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listDataGrantsPaginator(
        _ input: ListDataGrantsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListDataGrantsRequest, ListDataGrantsResponse> {
        return .init(
            input: input,
            command: self.listDataGrants,
            inputKey: \ListDataGrantsRequest.nextToken,
            outputKey: \ListDataGrantsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listDataGrants(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listDataGrantsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListDataGrantsRequest, ListDataGrantsResponse> {
        let input = ListDataGrantsRequest(
            maxResults: maxResults
        )
        return self.listDataGrantsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listDataSetRevisions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listDataSetRevisionsPaginator(
        _ input: ListDataSetRevisionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListDataSetRevisionsRequest, ListDataSetRevisionsResponse> {
        return .init(
            input: input,
            command: self.listDataSetRevisions,
            inputKey: \ListDataSetRevisionsRequest.nextToken,
            outputKey: \ListDataSetRevisionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listDataSetRevisions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - dataSetId: The unique identifier for a data set.
    ///   - maxResults: The maximum number of results returned by a single call.
    ///   - logger: Logger used for logging
    @inlinable
    public func listDataSetRevisionsPaginator(
        dataSetId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListDataSetRevisionsRequest, ListDataSetRevisionsResponse> {
        let input = ListDataSetRevisionsRequest(
            dataSetId: dataSetId, 
            maxResults: maxResults
        )
        return self.listDataSetRevisionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listDataSets(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listDataSetsPaginator(
        _ input: ListDataSetsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListDataSetsRequest, ListDataSetsResponse> {
        return .init(
            input: input,
            command: self.listDataSets,
            inputKey: \ListDataSetsRequest.nextToken,
            outputKey: \ListDataSetsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listDataSets(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results returned by a single call.
    ///   - origin: A property that defines the data set as OWNED by the account (for providers) or ENTITLED to the account (for subscribers).
    ///   - logger: Logger used for logging
    @inlinable
    public func listDataSetsPaginator(
        maxResults: Int? = nil,
        origin: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListDataSetsRequest, ListDataSetsResponse> {
        let input = ListDataSetsRequest(
            maxResults: maxResults, 
            origin: origin
        )
        return self.listDataSetsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listEventActions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listEventActionsPaginator(
        _ input: ListEventActionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListEventActionsRequest, ListEventActionsResponse> {
        return .init(
            input: input,
            command: self.listEventActions,
            inputKey: \ListEventActionsRequest.nextToken,
            outputKey: \ListEventActionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listEventActions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - eventSourceId: The unique identifier for the event source.
    ///   - maxResults: The maximum number of results returned by a single call.
    ///   - logger: Logger used for logging
    @inlinable
    public func listEventActionsPaginator(
        eventSourceId: String? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListEventActionsRequest, ListEventActionsResponse> {
        let input = ListEventActionsRequest(
            eventSourceId: eventSourceId, 
            maxResults: maxResults
        )
        return self.listEventActionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listJobsPaginator(
        _ input: ListJobsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListJobsRequest, ListJobsResponse> {
        return .init(
            input: input,
            command: self.listJobs,
            inputKey: \ListJobsRequest.nextToken,
            outputKey: \ListJobsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - dataSetId: The unique identifier for a data set.
    ///   - maxResults: The maximum number of results returned by a single call.
    ///   - revisionId: The unique identifier for a revision.
    ///   - logger: Logger used for logging
    @inlinable
    public func listJobsPaginator(
        dataSetId: String? = nil,
        maxResults: Int? = nil,
        revisionId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListJobsRequest, ListJobsResponse> {
        let input = ListJobsRequest(
            dataSetId: dataSetId, 
            maxResults: maxResults, 
            revisionId: revisionId
        )
        return self.listJobsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listReceivedDataGrants(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listReceivedDataGrantsPaginator(
        _ input: ListReceivedDataGrantsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListReceivedDataGrantsRequest, ListReceivedDataGrantsResponse> {
        return .init(
            input: input,
            command: self.listReceivedDataGrants,
            inputKey: \ListReceivedDataGrantsRequest.nextToken,
            outputKey: \ListReceivedDataGrantsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listReceivedDataGrants(_:logger:)``.
    ///
    /// - Parameters:
    ///   - acceptanceState: The acceptance state of the data grants to list.
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listReceivedDataGrantsPaginator(
        acceptanceState: [AcceptanceStateFilterValue]? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListReceivedDataGrantsRequest, ListReceivedDataGrantsResponse> {
        let input = ListReceivedDataGrantsRequest(
            acceptanceState: acceptanceState, 
            maxResults: maxResults
        )
        return self.listReceivedDataGrantsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listRevisionAssets(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listRevisionAssetsPaginator(
        _ input: ListRevisionAssetsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListRevisionAssetsRequest, ListRevisionAssetsResponse> {
        return .init(
            input: input,
            command: self.listRevisionAssets,
            inputKey: \ListRevisionAssetsRequest.nextToken,
            outputKey: \ListRevisionAssetsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listRevisionAssets(_:logger:)``.
    ///
    /// - Parameters:
    ///   - dataSetId: The unique identifier for a data set.
    ///   - maxResults: The maximum number of results returned by a single call.
    ///   - revisionId: The unique identifier for a revision.
    ///   - logger: Logger used for logging
    @inlinable
    public func listRevisionAssetsPaginator(
        dataSetId: String,
        maxResults: Int? = nil,
        revisionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListRevisionAssetsRequest, ListRevisionAssetsResponse> {
        let input = ListRevisionAssetsRequest(
            dataSetId: dataSetId, 
            maxResults: maxResults, 
            revisionId: revisionId
        )
        return self.listRevisionAssetsPaginator(input, logger: logger)
    }
}

extension DataExchange.ListDataGrantsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DataExchange.ListDataGrantsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension DataExchange.ListDataSetRevisionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DataExchange.ListDataSetRevisionsRequest {
        return .init(
            dataSetId: self.dataSetId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension DataExchange.ListDataSetsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DataExchange.ListDataSetsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            origin: self.origin
        )
    }
}

extension DataExchange.ListEventActionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DataExchange.ListEventActionsRequest {
        return .init(
            eventSourceId: self.eventSourceId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension DataExchange.ListJobsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DataExchange.ListJobsRequest {
        return .init(
            dataSetId: self.dataSetId,
            maxResults: self.maxResults,
            nextToken: token,
            revisionId: self.revisionId
        )
    }
}

extension DataExchange.ListReceivedDataGrantsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DataExchange.ListReceivedDataGrantsRequest {
        return .init(
            acceptanceState: self.acceptanceState,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension DataExchange.ListRevisionAssetsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DataExchange.ListRevisionAssetsRequest {
        return .init(
            dataSetId: self.dataSetId,
            maxResults: self.maxResults,
            nextToken: token,
            revisionId: self.revisionId
        )
    }
}
